///**
// *
// *
// */
//int retornaMenorDistancia(int elementoComparado) {
//    double min = MAX_INPUT;
//    if (elementoComparado < qntPontos / 2)
//        for (int i = 0; i < qntPontos; i++) {
//            for (int j = 0; j < qntPontos; j++) {
//                if (i != elementoComparado)
//                    if (min > distancias[elementoComparado][i] && podeVisitar(i)) {
//                        elementoComparado = i;
//                        min = distancias[elementoComparado][i];
//                    }
//            }
//        }
//    if (elementoComparado != 0) {
//        if (elementoComparado == 99999999)
//            return 0;
//        return elementoComparado;
//    }
//    return 999;
//}
//
///**
// * Metodo que retorna true se pode se a requisicao pode ser visitada, false caso contrario
// *
// */
//bool podeVisitar(int elemento) {
//    if (vetorControleVisita[elemento])//
//        return true;
//    else
//        return false;
//}
//
///**
// * Metodo que marca como visitado a requisi√ß√£o do cliente
// *
// */
//void marcaComoVisitado(int embarque, int desembarque) {
//    vetorControleVisita[embarque] = false;
//    vetorControleVisita[desembarque] = false;
//}///home/daniel/NetBeansProjects/TEstes/TesteCPP
//
//
//
//void heuristicaDeProgramacao(vector<Rota> solucao){
//
//    vector<double> A, B, D, R, W, T, Q, F, s, e , l;
//    vector<int> elementosDaRota,  acao ;
//    Rota rotaDaVez = Rota( elementosDaRota, A, B, D, W, R, T, Q, F);
//
//    for (int k = 0; k < solucao.size(); k++) {//Para cada rota calcularemos o atraso
//        rotaDaVez = solucao.at(k);
//        A = rotaDaVez.getA();
//        B = rotaDaVez.getB();
//        D = rotaDaVez.getD();
//        R = rotaDaVez.getR();
//        W = rotaDaVez.getW();
//        T = rotaDaVez.getT();
//        Q = rotaDaVez.getQ();
//        F = rotaDaVez.getF();
//        elementosDaRota = rotaDaVez.getRota();
//        int aux = 0;
//        /*vetorLocation.at(i).setIdReq(idPontoLeitura[i]);
//        vetorLocation.at(i).setCoordX(coordXLeitura[i]);
//        vetorLocation.at(i).setCoordY(coordYLeitura[i]);
//        vetorLocation.at(i).setE(inicioJanelaLeitura[i]);
//        vetorLocation.at(i).setL(fimJanelaLeitura[i]);
//        vetorLocation.at(i).setS(tempServPontoLeitura[i]);
//        vetorLocation.at(i).setAcao(infoPontoLeitura[i]);
//         * */
//        for (int i = 0; i < elementosDaRota.size(); i++) {
//            aux = elementosDaRota.at(i);//Retorna o id
//            e.push_back(vetorLocation.at(i).getE());
//            l.push_back(vetorLocation.at(i).getL());
//            s.push_back(vetorLocation.at(i).getS());
//            acao.push_back(vetorLocation.at(i).getAcao());
//        }
//        //Inicializa Vari√°veis
//        W[0]  = 0;
//        A[0]  = 0;
//        Q[0]  = 0;
//        B[0]  = 0;
//        D[0]  = 0;
//
//        calculaVariaveis(A, B, D, W, R, Q, e, s, acao, elementosDaRota);
//	calculaFO(F,l,R,B,W, elementosDaRota,tempMaxCaronaCliente_R);
//
//        double somaWp = 0;
//	somaWp = calculaSomatorioWp(somaWp,W);
//        B[0]= ( e.at(0) + min(F.at(0), somaWp));
//	atualizaVariaveis(A, B, W, D, e, s, elementosDaRota);
//	calcularR(B, D, R, elementosDaRota);//Calcular somente os pontos de embarque
//        for (int i = 1; i < elementosDaRota.size(); i++) {//Calcular vo != v1 SOMENTE PARA OS PONTOS DE EMBARQUE
//            calculaFO(F, l, R, B, W, elementosDaRota, tempMaxCaronaCliente_R);
//            somaWp = calculaSomatorioWp(somaWp, W);
//            if(elementosDaRota.at(i) < limiteDosEmbarques )
//		if(elementosDaRota.at(i) != 0){
//                    B[i] = (B.at(i) + min(F.at(i), somaWp));
//                    D[i] = (B.at(i) + s.at(i));
//                    W[i] = (B.at(i) - A.at(i));
//                    atualizaVariaveis(A, B, W, D, e ,s,elementosDaRota);
//                    atualizaR(B, D, R, elementosDaRota);
//                }
//        }//Fim FOR
//     }//Fim FOR
//}
//
//void calculaVariaveis(vector<double> A, vector<double> B, vector<double> D, vector<double> W, vector<double> R, vector<double> Q,
//            vector<double> e, vector<double> s, vector<int> acao, vector<int> elementosDaRota)
//{
//    int i = 0;
//    for (vector<int> ::iterator it = elementosDaRota.begin(); it!= elementosDaRota.end(); it++) {//P e U
//	A[i] =
//                (D.at(i-1) +
//                t[i-1][i]);//Para P U G+
//	B[i] = max(e[i], A.at(i));//Para P U G+
//	if(A.size() != i){
//            D[i] =  (B.at(i) + s[i]); //Para P e U
//            Q[i] = (Q.at(i-1) + acao[i]);
//	}else{
//            D[i] = (B.at(i));//Para G+
//            double zero = 0;
//            Q[i] = zero;
//	}
//	W[i] = (B.at(i) - A.at(i)); //Para P U G+
//	if(elementosDaRota.at(i) < limiteDosEmbarques )
//            if(elementosDaRota.at(i) != 0){
//                int indiceDesembarque = indexOf(elementosDaRota,limiteDosEmbarques + elementosDaRota.at(i));
//		//PEGAR O INDICE DO ELEMENTO APOS O LIMITE DO EMBARQUE DA ROTA
//		R[i] = (B.at(indiceDesembarque) - D.at(i));
//            }
//        i++;
//        }
//}
//int indexOf(vector<int> elementosDaRota, int elemento){
//    for (vector<int> ::iterator it = elementosDaRota.begin(); it!= elementosDaRota.end(); it++) {//P e U
//        if(elementosDaRota[*it] == elemento){
//            return *it;
//        }
//    }
//}
//
//void calculaFO(vector<double> F,vector<double> l,vector<double> R,vector<double> B,vector<double> W, vector<int>elementosDaRota,
//        int tempMaxCaronaCliente_R){
//
//
//    double somatorioW = 0, minimoFO, zero = 0;;
//    for (int j = 0; j < elementosDaRota.size(); j++) {
//	minimoFO = 9999;
//	if(j != 0 && j<=limiteDosEmbarques ){
//            for (int p = 0; p < j; p++) {
//                somatorioW += W.at(p);
//            }
//            if(minimoFO > (somatorioW + min(l.at(j) - B.at(j),  tempMaxCaronaCliente_R - R.at(j))))
//                minimoFO = (somatorioW + min(l.at(j) - B.at(j), tempMaxCaronaCliente_R - R.at(j)));
//            F[0] = min(somatorioW, minimoFO);
//	}else
//            if(j == 0){
//                for (int p = 0; p < j; p++) {
//                    somatorioW += W.at(p);
//		}
//		if(minimoFO > (somatorioW + min(l.at(j) - B.at(j), tempMaxCaronaCliente_R - R.at(j))))
//                    minimoFO = (somatorioW + min(l.at(j) - B.at(j), tempMaxCaronaCliente_R - R.at(j)));
//                    F[j] = min(somatorioW, minimoFO);
//		}else
//                    F[j] =  zero;
//    }
//
//
//}
//double calculaSomatorioWp(double somaWp, vector<double> W){
//for (int z = 1; z < W.size(); z++) {
//    somaWp += W.at(z);
//}
//return somaWp;
//}
////atualizaVariaveis(A, B, W, D, e, s, elementosDaRota);
//void atualizaVariaveis(vector<double> A, vector<double> B,  vector<double> W, vector<double> D, vector<double> e, vector<double> s,
//         vector<int> elementosDaRota){
//    int i = 0;
//    for (vector<int> ::iterator it = elementosDaRota.begin(); it!= elementosDaRota.end(); it++) {//P e U
//        A[i] = (D.at(i-1) + t[i-1][i]);//Para P U G+
//	B[i] = max(e[i], A.at(i));//Para P U G+
//	if(A.size() != i){
//            D[i] = (B.at(i) + s[i]); //Para P e U
//	}else{
//            D[i] = (B.at(i));//Para G+
//	}
//	W[i] = (B.at(i) - A.at(i)); // Para P U G+
//        i++;
//    }
//}
//
//void calcularR(vector<double> B, vector<double>  D, vector<double>  R, vector<int>  elementosDaRota){
//    int i = 0;
//    for (vector<int> ::iterator it = elementosDaRota.begin(); it!= elementosDaRota.end(); it++) {//P e U
//	if(elementosDaRota.at(i) < limiteDosEmbarques )
//        	if(elementosDaRota.at(i) != 0){
//                	int indiceDesembarque = indexOf(elementosDaRota,limiteDosEmbarques + elementosDaRota.at(i));//elementosDaRota.indexOf(limiteDosEmbarques + elementosDaRota.at(i));
//			//PEGAR O INDICE DO ELEMENTO APOS O LIMITE DO EMBARQUE DA ROTA
//			R[i] = (B.at(indiceDesembarque) - D.at(i));
//		}
//        i++;
//    }
//
//}
//
//void atualizaR(vector<double> B, vector<double>  D, vector<double>  R, vector<int>  elementosDaRota){
//    int i = 0;
//    for (vector<int> ::iterator it = elementosDaRota.begin(); it!= elementosDaRota.end(); it++) {//P e U
//	if(elementosDaRota.at(i) < limiteDosEmbarques )
//        	if(elementosDaRota.at(i) != 0){
//                    int indiceDesembarque = indexOf(elementosDaRota,limiteDosEmbarques + elementosDaRota.at(i));//elementosDaRota.indexOf(limiteDosEmbarques + elementosDaRota.at(i));
//					//PEGAR O INDICE DO ELEMENTO APOS O LIMITE DO EMBARQUE DA ROTA
//                    R[i] = (B.at(indiceDesembarque) - D.at(i));
//		}
//        i++;
//    }
//
//
//}
//
//
//double calculaFuncaoObjetivo(vector<Rota> solucao){
//    double  termoUmUm = 0, termoUmDois = 0, termoUmTres = 0, termoUmQuatro = 0, termoUmCinco = 0, //Os termos estao conforme a funcao
//           termoDoisUm = 0 , termoDoisDois = 0, termoDoisTres = 0,
//	   termoTresUm = 0, termoTresDois = 0;
//    vector<int> elementosDaRota;
//    vector<double> B , D, W, R, T, Q, e //= new vector<double>()
//    , l;// = new vector<double>();
//    int k = 0;
//    //for (int k = 0; k < solucao.size(); k++) {
//    for (vector<int> ::iterator it = elementosDaRota.begin(); it!= elementosDaRota.end(); it++) {//P e U
//    //			System.out.println("CALCULA FO =="+k+"= de ="+(solucao.size()-1));
//
//        Rota rota = solucao.at(k);
//	elementosDaRota = rota.getRota();
//	B = rota.getB();
//	D = rota.getD();
//	W = rota.getW();
//	//			System.out.println("R com "+rota.getR().size() + ">>"+rota.getR().toString());
//	R = rota.getR();
//	T = rota.getT();
//	Q = rota.getQ();
//	//			e = rota.getE();
//	//			l = rota.getL();
//	int aux = 0;
//	for (int i = 0; i < elementosDaRota.size(); i++) {
//        	aux = elementosDaRota.at(i);//Retorna o id
//        	//e.insert(i,e_Location[aux]);
//		//l.insert(i,l_Location[aux]);
//                e.push_back(vetorLocation.at(i).getE());
//                l.push_back(vetorLocation.at(i).getL());
//
//	//				s.add(i,s_Location[aux]);
//	//				acao.add(i, acao_Location[aux]);
//	}
//			//Somatorio das distancias
//	for (int i = 0; i < elementosDaRota.size()-1; i++) {
//            if(elementosDaRota.at(i)!= elementosDaRota.at(i+1))
//                termoUmUm += distancias[elementosDaRota.at(i)][elementosDaRota.at(i+1)];
//        }
//
//        //Somatorio dos veiculos
//	termoUmDois += 1;
//	//Somatorio dos tempos de inicio da viagem da garagem inicial menos o tempo de chegada na garagem final
//	termoUmTres +=  B.at(elementosDaRota.at(0)) - D.at(elementosDaRota.at((elementosDaRota.size() - 1)));
//
//        for (int i = 1; i < elementosDaRota.size() -1; i++) {//Tiramos as garagens
//		if (elementosDaRota.at(i) < limiteDosEmbarques) {//i E P
//		//Somatorio do tempo de viagem
//                    termoUmQuatro += R.at(i);
//		}
//		//Somatorio do tempo de espera
//		termoUmCinco += W.at(i);
//	}
//	//==================== Passamos para o segundo termo
//	//Calcula o somatorio
//	termoDoisUm += max(0.0, (B.at(0) - D.at(elementosDaRota.size()-1)) - rota.getTempoTotalDestaRota());
//
//	//Calcula o somatorio
//	int tempoMaxViagemCliente = rota.getTempoMaximoDeViagemPermitido();
//
//	for (int i = 1; i < elementosDaRota.size() -1; i++) {
//            if(elementosDaRota.at(i) < limiteDosEmbarques)
//		termoDoisDois += max(0.0, (R.at(i) - tempoMaxViagemCliente));
//	}
//
//	//Calcula o somatorio
//	//double[] tempoMaxEsperaNoPonto = rota.getTempoMaximoDeEspera();
//
//	for (int i = 1; i < elementosDaRota.size() -1; i++) {
//            if(elementosDaRota.at(i) < limiteDosEmbarques)
//		termoDoisTres += max(0.0,(W.at(i) - W_TempoMaximo_Espera));
//	}
//

//	double somatorio = 0;
//	int* acao = acao_Location;
//	//			System.out.println("A Carga M√°xima do ve√≠culo √© "+ cargaMaximaDoVeiculo);
//	for (int i = 1; i < elementosDaRota.size(); i++) {
//    	//	System.out.println("ELemento de tamanho"+ elementosDaRota.size()+"esta em "+i);
//	//				for (int j = 1; j < elementosDaRota.size()-1; j++) {
//	//					if(i!= j && j != limiteDosEmbarques - i){
//        	somatorio += acao[elementosDaRota.at(i)];
//		if(somatorio > cargaMaximaDoVeiculo){
//			termoTresUm += somatorio - cargaMaximaDoVeiculo;
//		}
//	//System.out.println("Termo "+i+"eh "+somatorio);
//				//						System.out.println("Acao "+acao[elementosDaRota.get(i)]);
//				//					}
//				//				}
//	}
//			//			termoTresUm += Math.max(0, somatorio - cargaMaximaDoVeiculo);
//
//
//			//			for (int i = 1; i < elementosDaRota.size()-1; i++) {
//			//				double somatorio = 0; int[] acao = acao_Location;
//			//				System.out.println("ELemento de tamanho"+ elementosDaRota.size()+"esta em "+i);
//			//				for (int j = 1; j < elementosDaRota.size()-1; j++) {
//			//					if(i!= j && j != limiteDosEmbarques - i){
//			//						somatorio += acao[elementosDaRota.get(i)];
//			//						System.out.println("Acao "+acao[elementosDaRota.get(i)]);
//			//					}
//			//				}
//			//				termoTresUm += Math.max(0, somatorio - cargaMaximaDoVeiculo);
//			//				System.out.println("Termo "+i+"eh "+somatorio);
//			//
//			//			}
//
//			//Somatorio
//	for (int i = 0; i < elementosDaRota.size(); i++) {
//        	termoTresDois += max(0.0, (e.at(i) - B.at(i)) + max(0.0, B.at(i) - l.at(i)));
//	}
//
//        //			funcaoObjetivo =termoUmUm() + w1*termoUmDois()+termoUmTres()+termoUmQuatro()+termoUmCinco();
//	funcaoObjetivo = w0*termoUmUm + w1*termoUmDois + w2*termoUmTres + w3*termoUmQuatro + w4*termoUmCinco +
//                         b0*termoDoisUm + b1*termoDoisDois + b2*termoDoisTres +
//			 b3*termoTresUm	+ b4*termoTresDois;
//        k++;
//    }
//	cout<< "T11 "<<termoUmUm<<"\n T12 "<<termoUmDois<<"\n T13 "<<termoUmTres<<"\n T14 "<<termoUmQuatro<<
//				"\n T15 "<<termoUmCinco<<"\n T21 "<<termoDoisUm<<"\n T22 "<<termoDoisDois<<"\n T23 "<<termoDoisTres<<
//				"\n T31 "<<termoTresUm<<"\n T32 "<<termoTresDois<<endl;
//	cout<< "\n Funcao Objetiva == valor: " << funcaoObjetivo << endl;
//	cout<<" ======================== Fim do Calcula Funcao Objetivo ========================" << endl;
//
//        return funcaoObjetivo;
//}
//vector<Rota> geraAleatoriamente(vector<Rota>* sol){
//    	cout<<" ======================== Inicio Gera Aleatoriamente ========================"<<endl;
//		int opcaoRandomica = (int) ((rand() * 4));
//                vector<Rota> solucaoAux;
//		switch (opcaoRandomica) {
//		case 0:
//
//			solucaoAux = reordenarRota(sol);//Passando a lista original
//
//			break;
//
//		case 1:
//			//solucaoAux =realocaPonto(sol); //Copiando a lista e passando como parametro
//                        solucaoAux =realocaPonto(sol);
//			break;
//
//		case 2:
//			solucaoAux =trocaPontos(sol);
//			break;
//
//		default:
//			solucaoAux =realocaBlocosEmbarque(sol);
//			break;
//		}
//		cout<<" ======================== Fim do Gera Aleatoriamente ========================"<<endl;
//
//                return solucaoAux;
//
//}
//
///*************************************************************************************************************
// *************************************************************************************************************
// *************************************  ESTRUTURAS DE VIZINHANCA   *******************************************
// *************************************************************************************************************
// *************************************************************************************************************/
//
//vector<Rota>* reordenarRota(vector<Rota> solucaoMetodo){
//
//
//    return solucaoMetodo;
//}
//
////vector<Rota> realocaPontos(vector<Rota> *solucaoMetodo){//Passaria a solucao original para ser modificada
//vector<Rota> realocaPonto(vector<Rota> solucaoMetodo){
//    return solucaoMetodo;
//}
//
//vector<Rota> trocaPontos(vector<Rota> solucaoMetodo){
//    return solucaoMetodo;
//}
//
//vector<Rota> realocaBlocosEmbarque(vector<Rota> solucaoMetodo){
//    return solucaoMetodo;
//}
//
